home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 10 / AACD 10.iso / AACD / Games / MAME / src / vidhrdw / prehisle.c < prev    next >
C/C++ Source or Header  |  2000-04-23  |  8KB  |  311 lines
  1. /***************************************************************************
  2.  
  3.     Prehistoric Isle video routines
  4.  
  5.     Emulation by Bryan McPhail, mish@tendril.co.uk
  6.  
  7. ***************************************************************************/
  8.  
  9. #include "driver.h"
  10. #include "vidhrdw/generic.h"
  11.  
  12. static struct osd_bitmap *pf1_bitmap,*pf2_bitmap;
  13. unsigned char *prehisle_video;
  14. static int vid_control[32],dirty_back,dirty_front;
  15.  
  16. /******************************************************************************/
  17.  
  18. void prehisle_vh_screenrefresh(struct osd_bitmap *bitmap, int full_refresh)
  19. {
  20.     int offs,mx,my,color,tile,i;
  21.     int colmask[0x80],code,pal_base,tile_base;
  22.     int scrollx,scrolly;
  23.     unsigned char *tilemap = memory_region(REGION_GFX5);
  24.     static int old_base=0xfffff,old_front=0xfffff;
  25.  
  26.     /* Build the dynamic palette */
  27.     palette_init_used_colors();
  28.  
  29.     /* Text layer */
  30.     pal_base = Machine->drv->gfxdecodeinfo[0].color_codes_start;
  31.     for (color = 0;color < 16;color++) colmask[color] = 0;
  32.     for (offs = 0;offs <0x800;offs += 2)
  33.     {
  34.         code = READ_WORD(&videoram[offs]);
  35.         color=code>>12;
  36.         if (code==0xff20) continue;
  37.         colmask[color] |= Machine->gfx[0]->pen_usage[code&0xfff];
  38.     }
  39.     for (color = 0;color < 16;color++)
  40.     {
  41.         for (i = 0;i < 15;i++)
  42.         {
  43.             if (colmask[color] & (1 << i))
  44.                 palette_used_colors[pal_base + 16 * color + i] = PALETTE_COLOR_USED;
  45.         }
  46.     }
  47.  
  48.     /* Tiles - bottom layer */
  49.     pal_base = Machine->drv->gfxdecodeinfo[1].color_codes_start;
  50.     for (offs=0; offs<256; offs++)
  51.         palette_used_colors[pal_base + offs] = PALETTE_COLOR_USED;
  52.  
  53.     /* Tiles - top layer */
  54.     pal_base = Machine->drv->gfxdecodeinfo[2].color_codes_start;
  55.     for (color = 0;color < 16;color++) colmask[color] = 0;
  56.     for (offs = 0x0000;offs <0x4000;offs += 2 )
  57.     {
  58.         code = READ_WORD(&prehisle_video[offs]);
  59.         color= code>>12;
  60.         colmask[color] |= Machine->gfx[2]->pen_usage[code&0x7ff];
  61.     }
  62.     for (color = 0;color < 16;color++)
  63.     {
  64.         for (i = 0;i < 15;i++)
  65.         {
  66.             if (colmask[color] & (1 << i))
  67.                 palette_used_colors[pal_base + 16 * color + i] = PALETTE_COLOR_USED;
  68.         }
  69.  
  70. ///* kludge */
  71. palette_used_colors[pal_base + 16 * color +15] = PALETTE_COLOR_TRANSPARENT;
  72. palette_change_color(pal_base + 16 * color +15 ,0,0,0);
  73.  
  74.     }
  75.  
  76.     /* Sprites */
  77.     pal_base = Machine->drv->gfxdecodeinfo[3].color_codes_start;
  78.     for (color = 0;color < 16;color++) colmask[color] = 0;
  79.     for (offs = 0;offs <0x400;offs += 8 )
  80.     {
  81.         code = READ_WORD(&spriteram[offs+4])&0x1fff;
  82.         color= READ_WORD(&spriteram[offs+6])>>12;
  83.         if (code>0x13ff) code=0x13ff;
  84.         colmask[color] |= Machine->gfx[3]->pen_usage[code];
  85.     }
  86.     for (color = 0;color < 16;color++)
  87.     {
  88.         for (i = 0;i < 15;i++)
  89.         {
  90.             if (colmask[color] & (1 << i))
  91.                 palette_used_colors[pal_base + 16 * color + i] = PALETTE_COLOR_USED;
  92.         }
  93.     }
  94.  
  95.     if (palette_recalc()) {
  96.         dirty_back=1;
  97.         dirty_front=1;
  98.     }
  99.  
  100.     /* Calculate tilebase for background, 64 bytes per column */
  101.     tile_base=((READ_WORD(&vid_control[6])&0x3ff0)>>4)*64;
  102.     if (old_base!=tile_base) dirty_back=1; /* Redraw */
  103.     old_base=tile_base;
  104.  
  105.     /* Back layer, taken from tilemap rom */
  106.     if (dirty_back)
  107.     {
  108.         tile_base&=0xfffe; /* Safety */
  109.         dirty_back=0;
  110.  
  111.         for (mx=0; mx<17;mx++)
  112.         {
  113.             for (my=0; my<32;my++)
  114.             {
  115.                 tile = tilemap[1+tile_base] + (tilemap[tile_base]<<8);
  116.                 color = tile>>12;
  117.                 drawgfx(pf1_bitmap,Machine->gfx[1],
  118.                             (tile & 0x7ff) | 0x800,
  119.                             color,
  120.                             tile&0x800,0,
  121.                             16*mx,16*my,
  122.                             0,TRANSPARENCY_NONE,0);
  123.                 tile_base+=2;
  124.                 if (tile_base==0x10000) tile_base=0; /* Wraparound */
  125.             }
  126.         }
  127.     }
  128.  
  129.     scrollx=-(READ_WORD(&vid_control[6])&0xf);
  130.     scrolly=-READ_WORD(&vid_control[4]);
  131.     copyscrollbitmap(bitmap,pf1_bitmap,1,&scrollx,1,&scrolly,&Machine->drv->visible_area,TRANSPARENCY_NONE,0);
  132.  
  133.     /* Calculate tilebase for background, 64 bytes per column */
  134.     tile_base=((READ_WORD(&vid_control[2])&0xff0)>>4)*64;
  135.     if (old_front!=tile_base) dirty_front=1; /* Redraw */
  136.     old_front=tile_base;
  137.  
  138.     /* Back layer, taken from tilemap rom */
  139.     if (dirty_front)
  140.     {
  141.         tile_base&=0x3ffe; /* Safety */
  142.         dirty_front=0;
  143.  
  144.         for (mx=0; mx<17;mx++)
  145.         {
  146.             for (my=0; my<32;my++)
  147.             {
  148.                 tile = READ_WORD(&prehisle_video[tile_base]);
  149.                 color = tile>>12;
  150.                 drawgfx(pf2_bitmap,Machine->gfx[2],
  151.                             tile & 0x7ff,
  152.                             color,
  153.                             0,tile&0x800,
  154.                             16*mx,16*my,
  155.                             0,TRANSPARENCY_NONE,0);
  156.                 tile_base+=2;
  157.                 if (tile_base==0x4000) tile_base=0; /* Wraparound */
  158.             }
  159.         }
  160.     }
  161.  
  162.     scrollx=-(READ_WORD(&vid_control[2])&0xf);
  163.     scrolly=-READ_WORD(&vid_control[0]);
  164.     copyscrollbitmap(bitmap,pf2_bitmap,1,&scrollx,1,&scrolly,&Machine->drv->visible_area,TRANSPARENCY_PEN,palette_transparent_pen);
  165.  
  166.     /* Sprites */
  167.     for (offs = 0;offs <0x800 ;offs += 8) {
  168.         int x,y,sprite,colour,fx,fy;
  169.  
  170.         y=READ_WORD (&spriteram[offs+0]);
  171.         if (y>254) continue; /* Speedup */
  172.         x=READ_WORD (&spriteram[offs+2]);
  173.         if (x&0x200) x=-(0xff-(x&0xff));
  174.         if (x>256) continue; /* Speedup */
  175.  
  176.         sprite=READ_WORD (&spriteram[offs+4]);
  177.         colour=READ_WORD (&spriteram[offs+6])>>12;
  178.  
  179.         fy=sprite&0x8000;
  180.         fx=sprite&0x4000;
  181.  
  182.         sprite=sprite&0x1fff;
  183.  
  184.         if (sprite>0x13ff) sprite=0x13ff;
  185.  
  186.         drawgfx(bitmap,Machine->gfx[3],
  187.                 sprite,
  188.                 colour,fx,fy,x,y,
  189.                 &Machine->drv->visible_area,TRANSPARENCY_PEN,15);
  190.     }
  191.  
  192.     /* Text layer */
  193.     mx = -1;
  194.     my = 0;
  195.     for (offs = 0x000; offs < 0x800;offs += 2)
  196.     {
  197.         mx++;
  198.         if (mx == 32)
  199.         {
  200.             mx = 0;
  201.             my++;
  202.         }
  203.         tile = READ_WORD(&videoram[offs]);
  204.         color = tile>>12;
  205.         if ((tile&0xff)!=0x20)
  206.             drawgfx(bitmap,Machine->gfx[0],
  207.                     tile & 0xfff,
  208.                     color,
  209.                     0,0,
  210.                     8*mx,8*my,
  211.                     &Machine->drv->visible_area,TRANSPARENCY_PEN,15);
  212.     }
  213. }
  214.  
  215. /******************************************************************************/
  216.  
  217. int prehisle_vh_start (void)
  218. {
  219.     pf1_bitmap=osd_create_bitmap(256+16,512);
  220.     pf2_bitmap=osd_create_bitmap(256+16,512);
  221.     return 0;
  222. }
  223.  
  224. void prehisle_vh_stop (void)
  225. {
  226.     osd_free_bitmap(pf1_bitmap);
  227.     osd_free_bitmap(pf2_bitmap);
  228. }
  229.  
  230. WRITE_HANDLER( prehisle_video_w )
  231. {
  232.     int oldword = READ_WORD(&prehisle_video[offset]);
  233.     int newword = COMBINE_WORD(oldword,data);
  234.  
  235.     if (oldword != newword)
  236.     {
  237.         WRITE_WORD(&prehisle_video[offset],newword);
  238.         dirty_front=1; /* Redraw */
  239.     }
  240. }
  241.  
  242. READ_HANDLER( prehisle_video_r )
  243. {
  244.     return READ_WORD(&prehisle_video[offset]);
  245. }
  246.  
  247. static int controls_invert;
  248.  
  249. READ_HANDLER( prehisle_control_r )
  250. {
  251.     switch (offset) {
  252.         case 0x10: /* Player 2 */
  253.             return readinputport(1);
  254.  
  255.         case 0x20: /* Coins, tilt, service */
  256.             return readinputport(2);
  257.  
  258.         case 0x40: /* Player 1 */
  259.             return readinputport(0) ^ controls_invert;
  260.  
  261.         case 0x42: /* Dips */
  262.             return readinputport(3);
  263.  
  264.         case 0x44: /* Dips + VBL */
  265.             return readinputport(4);
  266.  
  267.         default:
  268.             logerror("%06x: read unknown control %02x\n",cpu_get_pc(),offset);
  269.             return 0;
  270.     }
  271. }
  272.  
  273. WRITE_HANDLER( prehisle_control_w )
  274. {
  275.     switch (offset) {
  276.         case 0:
  277.             WRITE_WORD(&vid_control[0],data);
  278.             break;
  279.         case 0x10:
  280.             WRITE_WORD(&vid_control[2],data);
  281.             break;
  282.  
  283.         case 0x20:
  284.             WRITE_WORD(&vid_control[4],data);
  285.             break;
  286.  
  287.         case 0x30:
  288.             WRITE_WORD(&vid_control[6],data);
  289.             break;
  290.  
  291.         case 0x46:
  292.             controls_invert = data ? 0xff : 0x00;
  293.             break;
  294.  
  295.         case 0x50:
  296.             WRITE_WORD(&vid_control[8],data);
  297.             break;
  298.  
  299.         case 0x52:
  300.             WRITE_WORD(&vid_control[10],data);
  301.             break;
  302.         case 0x60:
  303.             WRITE_WORD(&vid_control[12],data);
  304.             break;
  305.  
  306.         default:
  307.             logerror("%06x: write unknown control %02x\n",cpu_get_pc(),offset);
  308.             break;
  309.     }
  310. }
  311.